Formation analyse urbaine - Travaux pratiques sur R (carroyage, lissage, zones à façon) [Exercice]

Présentation

L’objectif est de mettre en pratique les techniques présentées dans le tutoriel, à partir de nouveaux jeux de données.

Les objectifs et les données utilisées

Pour cela, on utilise un jeux de données extrait d’un source open-data : les parkings publics géolocalisés dans dans l’agglomération bordelaise. Les données ont été téléchargées sur le site de l’open-data de Bordeaux Métropole et ont été retravaillées pour les besoins de l’exercice.

Par ailleurs, notre objectif sera d’étudier la situation du centre-ville de Bordeaux en termes de présence de places de stationnement, de proportion de places adaptées aux personnes à mobilité réduite et au prix de ces places. Le contour géographique du centre-ville de Bordeaux est fourni. À noter qu’il a été créé “à la main” par les auteurs de ce TP, et qu’il ne répond à aucune définition officielle ou urbanistique précise.

Par ailleurs, à la fin de ce TP, une dernière partie consistera à approximer le nombre d’habitants vivant dans le centre-ville de Bordeaux d’après les données Filosofi 2015 carroyées.

Comment travailler ?

• Connexion au SSPCloud
• Ouvrir un service RStudio
• Nouveau Script

Code source de ce tutoriel

Le code ayant permis de généré ce document est consultable ici.

Partie 0 : Installation de la session et importation des données

"Installation des packages

P our cette partie, allez chercher directement la solution ci-dessous (hors programme de cette formation).

Dans un premier temps, on installe tous les packages nécessaires :

• dplyr
• sf
• btb
• mapsf
• mapview

Par ailleurs, on installe aws.s3 pour importer les données stockées sous Minio (solution de stockage de données sous SSPCloud).

Pour information, mapview est un package de cartographie produisant des résultats proches de leaflet. Il est un peu plus rapide d’utilisation quant il s’agit de produire des résultats simples : notamment, il reprojette automatiquemeent les objets géogrpahiques que vous souhaitez cartographier. Vous trouverez davantage d’informations à propos ici.

## Liste des librairies utilisées
packages <-  c("dplyr","sf","btb","mapsf","mapview","aws.s3")

## Vérifier si la librairie est installée, si non l'installer, puis la charger
package.check <- lapply(
  packages,
  FUN = function(x) {
    if (!require(x, character.only = TRUE)) {
      install.packages(x, dependencies = TRUE)
      library(x, character.only = TRUE)
    }
  }
)

The downloaded binary packages are in
    /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T//RtmpbsxZtL/downloaded_packages

The downloaded binary packages are in
    /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T//RtmpbsxZtL/downloaded_packages

The downloaded binary packages are in
    /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T//RtmpbsxZtL/downloaded_packages

The downloaded binary packages are in
    /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T//RtmpbsxZtL/downloaded_packages

The downloaded binary packages are in
    /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T//RtmpbsxZtL/downloaded_packages

Chargement des données

Le code ci-dessous permet d’importer les données utilisées dans ce tutoriel. Elles sont stockées sous Minio, dans le “bucket public” : s3/kantunez/diffusion/projet_formation/r_lissage_spatial/.

Quelques informations concernant ces jeux de données :

• parkings.RDS : table de données géolocalisées concernant les parkings publics dans l’agglomération bordelaise. Pour chaque parking public, voici les variables renseignées :
  • ident : identifiant du parking public
  • exploit : exploitant
  • np_global : nombre total de places de stationnement
  • np_pmr : nombre de places de stationnement pour les personnes à mobilité réduite
  • th_heur : prix horaire
  • x : longitude
  • y : latitude
  • epsg : code EPSE (projection géographique)
• bordeaux_centre.gpkg : découpage à façon du centre-ville de Bordeaux, réalisé manuellement par les auteurs de ce tutoriel en utilisant le Geoportail.

Là encore, il suffit de copier-coller et éxecuter le code ci-dessous dans votre session RStudio.

bucket <- "kantunez"

parkings <- 
  aws.s3::s3read_using(
    FUN = base::readRDS,
    object = "diffusion/projet_formation/r_lissage_spatial/parking.RDS",
    bucket = bucket
    ,
    opts = list("region" = "")
  )

centreBdx <- 
  aws.s3::s3read_using(
    FUN = sf::st_read,
    object = "diffusion/projet_formation/r_lissage_spatial/bordeaux_centre.gpkg",
    bucket = bucket
    ,
    opts = list("region" = "")
  )

L’import en dehors du SSPCloud se fait de cette manière :

url_bucket <- "https://minio.lab.sspcloud.fr/"

object <- "diffusion/projet_formation/r_lissage_spatial/parking.RDS"
download.file(paste0(url_bucket,bucket,"/",object), destfile = "parking.RDS")
parkings <- readRDS("parking.RDS")

object <- "diffusion/projet_formation/r_lissage_spatial/bordeaux_centre.gpkg"
centreBdx <- st_read(paste0(url_bucket,bucket,"/",object))

Reading layer `bordeaux_centre' from data source 
  `https://minio.lab.sspcloud.fr/kantunez/diffusion/projet_formation/r_lissage_spatial/bordeaux_centre.gpkg' 
  using driver `GPKG'
Simple feature collection with 1 feature and 1 field
Geometry type: POLYGON
Dimension:     XY
Bounding box:  xmin: 415676.3 ymin: 6419503 xmax: 419826.9 ymax: 6425297
Projected CRS: RGF93 / Lambert-93

Fonction de cartographie : genercarte

Pour visualiser les résultats de vos lissages, on crée une fonction genercarte de cartographie s’appuyant sur le package mapsf. On pourra réutiliser cette fonction par la suite, et limiter ainsi le nombre de lignes à recopier dans le code à chaque exercice).

Pour importer cette fonction dans votre environnement global, copier-coller et executer le code ci-dessous.

genercarte <- function(sfcarLisse,nomvar,nbreaks=5,zone,titre){
  #'@param sfcarLisse : Table de carreaux portant les valeurs lissées
  #'@param nomvar : Nom de la variable lissée à cartographier
  #'@param nbreaks : Nombre de classes à représenter sur la carte (avec méthode des quantiles)
  #'@param zone : Polygone de la zone d'intérêt (ex : centre de Bordeaux)
  #'@param titre : Titre de la carte (chaîne de caracères)
  #'@returns : carte produite avec le package mapsf
  mf_init(x=sfcarLisse,theme = "agolalight")
  mf_map(x = sfcarLisse, 
         type = "choro",
         var=nomvar,
         breaks = "quantile",
         nbreaks = nbreaks,
         lwd=1,
         add = TRUE)
  mf_map(x = st_cast(zone[,c("geom")],"MULTILINESTRING"), 
         lwd=4,
         col="black",add = TRUE)
  mf_layout(title = titre,credits = "Insee-DSAU, Bordeaux Métropole, IGN, mapsf")
}

Phase 1 : Appropriation des données

Exercice 1

Répondre aux questions suivantes : 

- Combien de parkings publics sont répertoriés dans la base `parkings` ?
- Vérifier qu'il n'y a pas de données manquantes dans les variables de position géographiques.
- Regarder la distribution des variables (avec la fonction `base::summary`)

Solution

head(parkings)

    ident     exploit np_global np_pmr th_heur        x       y epsg
1 CUBPK95     METPARK       355      8     2.4 417429.7 6424607 2154
2 CUBPK84      KEOLIS       199      5     3.1 418293.2 6426830 2154
3 CUBPK97      KEOLIS       102     12     4.5 410470.1 6428201 2154
4 CUBPK99 INDIGO_PARK       952     20     0.0 418288.3 6426501 2154
5 CUBPK76      KEOLIS       206      5     4.5 414215.2 6430881 2154
6 CUBPK16     METPARK       667     14     2.8 417759.4 6421534 2154

nrow(parkings) 

[1] 87

# 87 parkings dans la base

# Absence de valeurs manquantes dans les xy ? => Vrai
sum(is.na(parkings$x))

[1] 0

sum(is.na(parkings$y))

[1] 0

# Distribution des variables
parkings %>% summary()

    ident             exploit            np_global          np_pmr         th_heur      
 Length:87          Length:87          Min.   :  46.0   Min.   : 0.00   Min.   : 0.000  
 Class :character   Class :character   1st Qu.: 162.0   1st Qu.: 4.00   1st Qu.: 2.400  
 Mode  :character   Mode  :character   Median : 341.0   Median : 7.00   Median : 3.100  
                                       Mean   : 473.9   Mean   : 9.08   Mean   : 3.296  
                                       3rd Qu.: 528.5   3rd Qu.:10.50   3rd Qu.: 4.050  
                                       Max.   :3427.0   Max.   :57.00   Max.   :14.500  
       x                y               epsg          
 Min.   :407552   Min.   :6414710   Length:87         
 1st Qu.:415311   1st Qu.:6420763   Class :character  
 Median :417608   Median :6421969   Mode  :character  
 Mean   :416684   Mean   :6422432                     
 3rd Qu.:418911   3rd Qu.:6424019                     
 Max.   :422710   Max.   :6433813                     

Exercice 2

Observer l'emprise du contour du centre-ville de Bordeaux en utilisant la fonction `mapview::mapview` (avec un fond de carte OpenStreetMap).

Indices

Il suffit d'écrire `mapview(tableVectorielleSouhaitee)`

Solution

mapview(centreBdx)

Exercice 3

- Transformer la base des parkings en format vectoriel et enregistrer la résultat dans la nouvelle variable `sfparking`:
- Cartographier conjointement le contour de Bordeaux-centre et les parkings en utilisant `mapview`.

Indices

- Transformer la base des parkings en format vectoriel et enregistrer la résultat dans la nouvelle variable `sfparking`:
  - Utiliser la fonction `sf::st_as_sf`
  - Attention à bien renseigner le système de projection des coordonnées xy dans le paramètre `crs`.
- Cartographier conjointement le contour de Bordeaux-centre et les parkings de la base :
  - On additionne les couches vectorielles avec "+" : `mapview(polygone)+mapview(points)` 

Solution

# Transformation en objet vectoriel (géographique)
sfparking <- sf::st_as_sf(parkings,coords=c("x","y"),crs=2154)

# Cartographie avec leaflet
mapview(centreBdx)+mapview(sfparking,col.region="black")

Phase 2 : Le lissage spatial

Partie 2.1 : Carroyer les données avant de lisser

Dans le cas présent, le petit nombre de parkings ne rend pas indispensable cette phase de carroyage. Elle permet néanmoins de s’approprier un peu plus la structure spatiale des données avec le lissage.

Exercice 4

- Créer une variable `iCellSize <- 1000` correspondant à la taille des carreaux souhaités
- Créer la table `centroides` des centroïdes des carreaux de 1000m :
  - À partir de la table `parkings`
  - En faisant des "modulo 1000" sur les coordonnées x et y
  - Comptabiliser le nombre de parkings`contenus dans chaque carreau (nouvelle variable `nbParkings`)

Indices

On peut créer de nouvelles variables x_centroide et y_centroide correspondant respectivement à x et y auxquelles : 
  - On retire le reste de leurs divisions euclidiennes de x modulo 1000 (respectivmeent y modulo 1000)
  - A ce stade, x_centroide et y_centroide détermine le point en bas à gauche du carreau de 1km
  - et on ajoute 1000/2 pour tomber sur le centre du carreau

A chaque parking est maintenant associé le couple x_centroide et y_centroide du carreau de 1km auquel le parking appartient.
En groupant la base de parkings sur le couple de centroides, on aboutit à la base souahitée.

Solution

# Taille des carreaux
iCellSize = 1000 

centroides <- parkings
centroides$x_centroide = as.integer(floor(centroides$x / iCellSize) * iCellSize + (iCellSize / 2))
centroides$y_centroide = as.integer(floor(centroides$y / iCellSize) * iCellSize + (iCellSize / 2))

# Compter le nombre de parkings par carreau
centroides <- centroides %>% 
  group_by(x=x_centroide,y=y_centroide) %>% 
  count(name = "nbParkings")

Exercice 5

- Transformer `centroides` en grille de carreaux grâce à la fonction `btb::dfToGrid` (et stocker le résultat dans la variable `sfcarreaux`)
- Restreindre cette base aux seuls carreaux intersectant le centre de Bordeaux
- Cartographie les carreaux et le contour du centre de Bordeaux avec `mapview`. 
- Colorier les carreaux différemment selon le nombre de parkings qu'ils contiennent.

Indices

Dans la fonction `mapview`, on peut utiliser les options : 
  - zcol = "nbParkings"
  - col.regions=list("grey","yellow","red")

Solution

# Générer la grille
sfcarreaux <- btb::dfToGrid(df = centroides, sEPSG = "2154", iCellSize = iCellSize)

# Restriction du champ : on ne retient que les carreaux intersectant Bordeaux-centre
sfcarreaux <- sfcarreaux[unlist(st_intersects(centreBdx,sfcarreaux)),]

# Cartographie
mapview(centreBdx,alpha.regions=0,lwd=4,legend=F)+mapview(sfcarreaux,zcol = "nbParkings",col.regions=list("grey","yellow","red"))

Partie 2.2 : Lissage de la densité des parkings

Exercice 6

- Créer un "buffer" du centre-ville de Bordeaux (avec une marge de 2000 mètres autour) et enregistrer le résultat dans `centreBdxBuffer`
- Sélectionner les parking intersectant cette zone tampon et enregistrer la nouvelle table `parkingBuff`

Indices

- Créer un "buffer" du centre-ville de Bordeaux (avec une marge de 2000 mètres autour) et enregistrer le résultat dans `centreBdxBuffer` ==> Utiliser la fonction `sf::st_buffer`
- Sélectionner les parking intersectant cette zone tampon et enregistrer la nouvelle table `parkingBuff` ==> Utiliser la fonction `sf::st_contains` ou `sf::st_intersects`

Solution

# Création d'un buffer autour du territoire
centreBdxBuffer <- st_buffer(centreBdx, dist = 2000)

# Représentation 
mapview(centreBdxBuffer,col.region="gray")+mapview(centreBdx)

# Repérer les indices des observations contenues dans notre buffer d'intérêt
indiceObsContenues <- unlist(sf::st_contains(centreBdxBuffer, sfparking))

# Réduire la base aux seules observations dans le territoire
parkingBuff <- parkings[indiceObsContenues, ]

Exercice 7

- Créer une variable nbObsLisse = 1L
- Lisser le nombre de parking dans le buffer du centre-ville de Bordeaux : 
    - Avec un rayon de lissage de 1 500 mètres
    - En générant une grille carroyée de 200 mètres de côté
- Restreindre les carreaux de 200 mètres obtenus aux seuls intersectant le centre-ville et enregistrer le résultat dans `sfcarLisse`
- Cartographier le résultat obtenu avec la fonction `genercarte` (chargée dans votre environnement global)

Indices

Utiliser la fonction `btb::kernelSmoothing`

Solution

# Nouvelle variable de "comptage des observation"
parkingBuff$nbObsLisse <- 1L

# Lissage
rayon <- 1500 # Rayon de lissage
tcar <-  200 # Taille des carreaux de la grille

parkingsLissage <- parkingBuff[,c("nbObsLisse","x","y")]
sfcarLisse <- btb::kernelSmoothing(dfObservations = parkingsLissage, 
                                    sEPSG = "2154",
                                    iCellSize = tcar, 
                                    iBandwidth = rayon)

Smoothing progress: 1% - minimum remaining time: 0m 0s
Smoothing progress: 3% - minimum remaining time: 0m 0s
Smoothing progress: 5% - minimum remaining time: 0m 0s
Smoothing progress: 7% - minimum remaining time: 0m 0s
Smoothing progress: 8% - minimum remaining time: 0m 0s
Smoothing progress: 10% - minimum remaining time: 0m 0s
Smoothing progress: 12% - minimum remaining time: 0m 0s
Smoothing progress: 14% - minimum remaining time: 0m 0s
Smoothing progress: 15% - minimum remaining time: 0m 0s
Smoothing progress: 17% - minimum remaining time: 0m 0s
Smoothing progress: 19% - minimum remaining time: 0m 0s
Smoothing progress: 21% - minimum remaining time: 0m 0s
Smoothing progress: 22% - minimum remaining time: 0m 0s
Smoothing progress: 24% - minimum remaining time: 0m 0s
Smoothing progress: 26% - minimum remaining time: 0m 0s
Smoothing progress: 28% - minimum remaining time: 0m 0s
Smoothing progress: 29% - minimum remaining time: 0m 0s
Smoothing progress: 31% - minimum remaining time: 0m 0s
Smoothing progress: 33% - minimum remaining time: 0m 0s
Smoothing progress: 35% - minimum remaining time: 0m 0s
Smoothing progress: 36% - minimum remaining time: 0m 0s
Smoothing progress: 38% - minimum remaining time: 0m 0s
Smoothing progress: 40% - minimum remaining time: 0m 0s
Smoothing progress: 42% - minimum remaining time: 0m 0s
Smoothing progress: 43% - minimum remaining time: 0m 0s
Smoothing progress: 45% - minimum remaining time: 0m 0s
Smoothing progress: 47% - minimum remaining time: 0m 0s
Smoothing progress: 49% - minimum remaining time: 0m 0s
Smoothing progress: 50% - minimum remaining time: 0m 0s
Smoothing progress: 52% - minimum remaining time: 0m 0s
Smoothing progress: 54% - minimum remaining time: 0m 0s
Smoothing progress: 56% - minimum remaining time: 0m 0s
Smoothing progress: 57% - minimum remaining time: 0m 0s
Smoothing progress: 59% - minimum remaining time: 0m 0s
Smoothing progress: 61% - minimum remaining time: 0m 0s
Smoothing progress: 63% - minimum remaining time: 0m 0s
Smoothing progress: 64% - minimum remaining time: 0m 0s
Smoothing progress: 66% - minimum remaining time: 0m 0s
Smoothing progress: 68% - minimum remaining time: 0m 0s
Smoothing progress: 70% - minimum remaining time: 0m 0s
Smoothing progress: 71% - minimum remaining time: 0m 0s
Smoothing progress: 73% - minimum remaining time: 0m 0s
Smoothing progress: 75% - minimum remaining time: 0m 0s
Smoothing progress: 77% - minimum remaining time: 0m 0s
Smoothing progress: 78% - minimum remaining time: 0m 0s
Smoothing progress: 80% - minimum remaining time: 0m 0s
Smoothing progress: 82% - minimum remaining time: 0m 0s
Smoothing progress: 84% - minimum remaining time: 0m 0s
Smoothing progress: 85% - minimum remaining time: 0m 0s
Smoothing progress: 87% - minimum remaining time: 0m 0s
Smoothing progress: 89% - minimum remaining time: 0m 0s
Smoothing progress: 91% - minimum remaining time: 0m 0s
Smoothing progress: 92% - minimum remaining time: 0m 0s
Smoothing progress: 94% - minimum remaining time: 0m 0s
Smoothing progress: 96% - minimum remaining time: 0m 0s
Smoothing progress: 98% - minimum remaining time: 0m 0s
Smoothing duration: 0m 0s                                                                                           

# Filtrage ==> ne garder que les carreaux intersectant le centre de Bordeaux
sfcarLisse <- sfcarLisse[unlist(st_intersects(centreBdx,sfcarLisse)),]

# Carte lissée
genercarte(sfcarLisse=sfcarLisse,
                       nomvar="nbObsLisse",
                       nbreaks=5,
                       zone=centreBdx,
                       titre="Lissage de la densité de parkings avec un rayon de 1500 m")

Exercice 8

Refaire le lissage avec un rayon de 600 mètres, puis avec un rayon de 2000 mètres

Solution

# Avec un rayon de 600m
rayon <- 600 # Rayon de lissage

sfcarLisse <- btb::kernelSmoothing(dfObservations = parkingsLissage, 
                                    sEPSG = "2154",
                                    iCellSize = tcar, 
                                    iBandwidth = rayon)

Smoothing progress: 1% - minimum remaining time: 0m 0s
Smoothing progress: 3% - minimum remaining time: 0m 0s
Smoothing progress: 5% - minimum remaining time: 0m 0s
Smoothing progress: 7% - minimum remaining time: 0m 0s
Smoothing progress: 8% - minimum remaining time: 0m 0s
Smoothing progress: 10% - minimum remaining time: 0m 0s
Smoothing progress: 12% - minimum remaining time: 0m 0s
Smoothing progress: 14% - minimum remaining time: 0m 0s
Smoothing progress: 15% - minimum remaining time: 0m 0s
Smoothing progress: 17% - minimum remaining time: 0m 0s
Smoothing progress: 19% - minimum remaining time: 0m 0s
Smoothing progress: 21% - minimum remaining time: 0m 0s
Smoothing progress: 22% - minimum remaining time: 0m 0s
Smoothing progress: 24% - minimum remaining time: 0m 0s
Smoothing progress: 26% - minimum remaining time: 0m 0s
Smoothing progress: 28% - minimum remaining time: 0m 0s
Smoothing progress: 29% - minimum remaining time: 0m 0s
Smoothing progress: 31% - minimum remaining time: 0m 0s
Smoothing progress: 33% - minimum remaining time: 0m 0s
Smoothing progress: 35% - minimum remaining time: 0m 0s
Smoothing progress: 36% - minimum remaining time: 0m 0s
Smoothing progress: 38% - minimum remaining time: 0m 0s
Smoothing progress: 40% - minimum remaining time: 0m 0s
Smoothing progress: 42% - minimum remaining time: 0m 0s
Smoothing progress: 43% - minimum remaining time: 0m 0s
Smoothing progress: 45% - minimum remaining time: 0m 0s
Smoothing progress: 47% - minimum remaining time: 0m 0s
Smoothing progress: 49% - minimum remaining time: 0m 0s
Smoothing progress: 50% - minimum remaining time: 0m 0s
Smoothing progress: 52% - minimum remaining time: 0m 0s
Smoothing progress: 54% - minimum remaining time: 0m 0s
Smoothing progress: 56% - minimum remaining time: 0m 0s
Smoothing progress: 57% - minimum remaining time: 0m 0s
Smoothing progress: 59% - minimum remaining time: 0m 0s
Smoothing progress: 61% - minimum remaining time: 0m 0s
Smoothing progress: 63% - minimum remaining time: 0m 0s
Smoothing progress: 64% - minimum remaining time: 0m 0s
Smoothing progress: 66% - minimum remaining time: 0m 0s
Smoothing progress: 68% - minimum remaining time: 0m 0s
Smoothing progress: 70% - minimum remaining time: 0m 0s
Smoothing progress: 71% - minimum remaining time: 0m 0s
Smoothing progress: 73% - minimum remaining time: 0m 0s
Smoothing progress: 75% - minimum remaining time: 0m 0s
Smoothing progress: 77% - minimum remaining time: 0m 0s
Smoothing progress: 78% - minimum remaining time: 0m 0s
Smoothing progress: 80% - minimum remaining time: 0m 0s
Smoothing progress: 82% - minimum remaining time: 0m 0s
Smoothing progress: 84% - minimum remaining time: 0m 0s
Smoothing progress: 85% - minimum remaining time: 0m 0s
Smoothing progress: 87% - minimum remaining time: 0m 0s
Smoothing progress: 89% - minimum remaining time: 0m 0s
Smoothing progress: 91% - minimum remaining time: 0m 0s
Smoothing progress: 92% - minimum remaining time: 0m 0s
Smoothing progress: 94% - minimum remaining time: 0m 0s
Smoothing progress: 96% - minimum remaining time: 0m 0s
Smoothing progress: 98% - minimum remaining time: 0m 0s
Smoothing duration: 0m 0s                                                                                           

sfcarLisse <- sfcarLisse[unlist(st_intersects(centreBdx,sfcarLisse)),]
genercarte(sfcarLisse=sfcarLisse,
                       nomvar="nbObsLisse",
                       nbreaks=5,
                       zone=centreBdx,
                       titre="Lissage de la densité de parkings avec un rayon de 600 m")

# Avec un rayon de 2000m
rayon <- 2000 # Rayon de lissage

sfcarLisse <- btb::kernelSmoothing(dfObservations = parkingsLissage, 
                                    sEPSG = "2154",
                                    iCellSize = tcar, 
                                    iBandwidth = rayon)

Smoothing progress: 1% - minimum remaining time: 0m 0s
Smoothing progress: 3% - minimum remaining time: 0m 0s
Smoothing progress: 5% - minimum remaining time: 0m 0s
Smoothing progress: 7% - minimum remaining time: 0m 0s
Smoothing progress: 8% - minimum remaining time: 0m 0s
Smoothing progress: 10% - minimum remaining time: 0m 0s
Smoothing progress: 12% - minimum remaining time: 0m 0s
Smoothing progress: 14% - minimum remaining time: 0m 0s
Smoothing progress: 15% - minimum remaining time: 0m 0s
Smoothing progress: 17% - minimum remaining time: 0m 0s
Smoothing progress: 19% - minimum remaining time: 0m 0s
Smoothing progress: 21% - minimum remaining time: 0m 0s
Smoothing progress: 22% - minimum remaining time: 0m 0s
Smoothing progress: 24% - minimum remaining time: 0m 0s
Smoothing progress: 26% - minimum remaining time: 0m 0s
Smoothing progress: 28% - minimum remaining time: 0m 0s
Smoothing progress: 29% - minimum remaining time: 0m 0s
Smoothing progress: 31% - minimum remaining time: 0m 0s
Smoothing progress: 33% - minimum remaining time: 0m 0s
Smoothing progress: 35% - minimum remaining time: 0m 0s
Smoothing progress: 36% - minimum remaining time: 0m 0s
Smoothing progress: 38% - minimum remaining time: 0m 0s
Smoothing progress: 40% - minimum remaining time: 0m 0s
Smoothing progress: 42% - minimum remaining time: 0m 0s
Smoothing progress: 43% - minimum remaining time: 0m 0s
Smoothing progress: 45% - minimum remaining time: 0m 0s
Smoothing progress: 47% - minimum remaining time: 0m 0s
Smoothing progress: 49% - minimum remaining time: 0m 0s
Smoothing progress: 50% - minimum remaining time: 0m 0s
Smoothing progress: 52% - minimum remaining time: 0m 0s
Smoothing progress: 54% - minimum remaining time: 0m 0s
Smoothing progress: 56% - minimum remaining time: 0m 0s
Smoothing progress: 57% - minimum remaining time: 0m 0s
Smoothing progress: 59% - minimum remaining time: 0m 0s
Smoothing progress: 61% - minimum remaining time: 0m 0s
Smoothing progress: 63% - minimum remaining time: 0m 0s
Smoothing progress: 64% - minimum remaining time: 0m 0s
Smoothing progress: 66% - minimum remaining time: 0m 0s
Smoothing progress: 68% - minimum remaining time: 0m 0s
Smoothing progress: 70% - minimum remaining time: 0m 0s
Smoothing progress: 71% - minimum remaining time: 0m 0s
Smoothing progress: 73% - minimum remaining time: 0m 0s
Smoothing progress: 75% - minimum remaining time: 0m 0s
Smoothing progress: 77% - minimum remaining time: 0m 0s
Smoothing progress: 78% - minimum remaining time: 0m 0s
Smoothing progress: 80% - minimum remaining time: 0m 0s
Smoothing progress: 82% - minimum remaining time: 0m 0s
Smoothing progress: 84% - minimum remaining time: 0m 0s
Smoothing progress: 85% - minimum remaining time: 0m 0s
Smoothing progress: 87% - minimum remaining time: 0m 0s
Smoothing progress: 89% - minimum remaining time: 0m 0s
Smoothing progress: 91% - minimum remaining time: 0m 0s
Smoothing progress: 92% - minimum remaining time: 0m 0s
Smoothing progress: 94% - minimum remaining time: 0m 0s
Smoothing progress: 96% - minimum remaining time: 0m 0s
Smoothing progress: 98% - minimum remaining time: 0m 0s
Smoothing duration: 0m 0s                                                                                           

sfcarLisse <- sfcarLisse[unlist(st_intersects(centreBdx,sfcarLisse)),]
genercarte(sfcarLisse=sfcarLisse,
                       nomvar="nbObsLisse",
                       nbreaks=5,
                       zone=centreBdx,
                       titre="Lissage de la densité de parkings avec un rayon de 2000 m")

Partie 2.3 : Lissage du nombre de places de parkings

Exercice 9

Lisser le nombre de places de stationnement (variable `np_global`), et non plus le nombre de parkings.
Pour la suite, toujours prendre un rayon de lissage de 1500 mètres sauf mention contraire.

Solution

rayon <- 1500
parkingsLissage <- parkingBuff[,c("np_global","x","y")]
sfcarLisse <- btb::kernelSmoothing(dfObservations = parkingsLissage, 
                                    sEPSG = "2154",
                                    iCellSize = tcar, 
                                    iBandwidth = rayon)

Smoothing progress: 1% - minimum remaining time: 0m 0s
Smoothing progress: 3% - minimum remaining time: 0m 0s
Smoothing progress: 5% - minimum remaining time: 0m 0s
Smoothing progress: 7% - minimum remaining time: 0m 0s
Smoothing progress: 8% - minimum remaining time: 0m 0s
Smoothing progress: 10% - minimum remaining time: 0m 0s
Smoothing progress: 12% - minimum remaining time: 0m 0s
Smoothing progress: 14% - minimum remaining time: 0m 0s
Smoothing progress: 15% - minimum remaining time: 0m 0s
Smoothing progress: 17% - minimum remaining time: 0m 0s
Smoothing progress: 19% - minimum remaining time: 0m 0s
Smoothing progress: 21% - minimum remaining time: 0m 0s
Smoothing progress: 22% - minimum remaining time: 0m 0s
Smoothing progress: 24% - minimum remaining time: 0m 0s
Smoothing progress: 26% - minimum remaining time: 0m 0s
Smoothing progress: 28% - minimum remaining time: 0m 0s
Smoothing progress: 29% - minimum remaining time: 0m 0s
Smoothing progress: 31% - minimum remaining time: 0m 0s
Smoothing progress: 33% - minimum remaining time: 0m 0s
Smoothing progress: 35% - minimum remaining time: 0m 0s
Smoothing progress: 36% - minimum remaining time: 0m 0s
Smoothing progress: 38% - minimum remaining time: 0m 0s
Smoothing progress: 40% - minimum remaining time: 0m 0s
Smoothing progress: 42% - minimum remaining time: 0m 0s
Smoothing progress: 43% - minimum remaining time: 0m 0s
Smoothing progress: 45% - minimum remaining time: 0m 0s
Smoothing progress: 47% - minimum remaining time: 0m 0s
Smoothing progress: 49% - minimum remaining time: 0m 0s
Smoothing progress: 50% - minimum remaining time: 0m 0s
Smoothing progress: 52% - minimum remaining time: 0m 0s
Smoothing progress: 54% - minimum remaining time: 0m 0s
Smoothing progress: 56% - minimum remaining time: 0m 0s
Smoothing progress: 57% - minimum remaining time: 0m 0s
Smoothing progress: 59% - minimum remaining time: 0m 0s
Smoothing progress: 61% - minimum remaining time: 0m 0s
Smoothing progress: 63% - minimum remaining time: 0m 0s
Smoothing progress: 64% - minimum remaining time: 0m 0s
Smoothing progress: 66% - minimum remaining time: 0m 0s
Smoothing progress: 68% - minimum remaining time: 0m 0s
Smoothing progress: 70% - minimum remaining time: 0m 0s
Smoothing progress: 71% - minimum remaining time: 0m 0s
Smoothing progress: 73% - minimum remaining time: 0m 0s
Smoothing progress: 75% - minimum remaining time: 0m 0s
Smoothing progress: 77% - minimum remaining time: 0m 0s
Smoothing progress: 78% - minimum remaining time: 0m 0s
Smoothing progress: 80% - minimum remaining time: 0m 0s
Smoothing progress: 82% - minimum remaining time: 0m 0s
Smoothing progress: 84% - minimum remaining time: 0m 0s
Smoothing progress: 85% - minimum remaining time: 0m 0s
Smoothing progress: 87% - minimum remaining time: 0m 0s
Smoothing progress: 89% - minimum remaining time: 0m 0s
Smoothing progress: 91% - minimum remaining time: 0m 0s
Smoothing progress: 92% - minimum remaining time: 0m 0s
Smoothing progress: 94% - minimum remaining time: 0m 0s
Smoothing progress: 96% - minimum remaining time: 0m 0s
Smoothing progress: 98% - minimum remaining time: 0m 0s
Smoothing duration: 0m 0s                                                                                           

# Filtrage des carreaux lissés dans Paris
sfcarLisse <- sfcarLisse[unlist(st_intersects(centreBdx,sfcarLisse)),]

# Carte lissée
genercarte(sfcarLisse=sfcarLisse,
                       nomvar="np_global",
                       nbreaks=5,
                       zone=centreBdx,
                       titre="Lissage des places de stationnement")

Exercice 10

Lisser le nombre de places de stationnement pour les personnes à mobilité réduite (variable `np_pmr`).

Solution

parkingsLissage <- parkingBuff[,c("np_pmr","x","y")]

sfcarLisse <- btb::kernelSmoothing(dfObservations = parkingsLissage, 
                                    sEPSG = "2154",
                                    iCellSize = tcar, 
                                    iBandwidth = rayon)

Smoothing progress: 1% - minimum remaining time: 0m 0s
Smoothing progress: 3% - minimum remaining time: 0m 0s
Smoothing progress: 5% - minimum remaining time: 0m 0s
Smoothing progress: 7% - minimum remaining time: 0m 0s
Smoothing progress: 8% - minimum remaining time: 0m 0s
Smoothing progress: 10% - minimum remaining time: 0m 0s
Smoothing progress: 12% - minimum remaining time: 0m 0s
Smoothing progress: 14% - minimum remaining time: 0m 0s
Smoothing progress: 15% - minimum remaining time: 0m 0s
Smoothing progress: 17% - minimum remaining time: 0m 0s
Smoothing progress: 19% - minimum remaining time: 0m 0s
Smoothing progress: 21% - minimum remaining time: 0m 0s
Smoothing progress: 22% - minimum remaining time: 0m 0s
Smoothing progress: 24% - minimum remaining time: 0m 0s
Smoothing progress: 26% - minimum remaining time: 0m 0s
Smoothing progress: 28% - minimum remaining time: 0m 0s
Smoothing progress: 29% - minimum remaining time: 0m 0s
Smoothing progress: 31% - minimum remaining time: 0m 0s
Smoothing progress: 33% - minimum remaining time: 0m 0s
Smoothing progress: 35% - minimum remaining time: 0m 0s
Smoothing progress: 36% - minimum remaining time: 0m 0s
Smoothing progress: 38% - minimum remaining time: 0m 0s
Smoothing progress: 40% - minimum remaining time: 0m 0s
Smoothing progress: 42% - minimum remaining time: 0m 0s
Smoothing progress: 43% - minimum remaining time: 0m 0s
Smoothing progress: 45% - minimum remaining time: 0m 0s
Smoothing progress: 47% - minimum remaining time: 0m 0s
Smoothing progress: 49% - minimum remaining time: 0m 0s
Smoothing progress: 50% - minimum remaining time: 0m 0s
Smoothing progress: 52% - minimum remaining time: 0m 0s
Smoothing progress: 54% - minimum remaining time: 0m 0s
Smoothing progress: 56% - minimum remaining time: 0m 0s
Smoothing progress: 57% - minimum remaining time: 0m 0s
Smoothing progress: 59% - minimum remaining time: 0m 0s
Smoothing progress: 61% - minimum remaining time: 0m 0s
Smoothing progress: 63% - minimum remaining time: 0m 0s
Smoothing progress: 64% - minimum remaining time: 0m 0s
Smoothing progress: 66% - minimum remaining time: 0m 0s
Smoothing progress: 68% - minimum remaining time: 0m 0s
Smoothing progress: 70% - minimum remaining time: 0m 0s
Smoothing progress: 71% - minimum remaining time: 0m 0s
Smoothing progress: 73% - minimum remaining time: 0m 0s
Smoothing progress: 75% - minimum remaining time: 0m 0s
Smoothing progress: 77% - minimum remaining time: 0m 0s
Smoothing progress: 78% - minimum remaining time: 0m 0s
Smoothing progress: 80% - minimum remaining time: 0m 0s
Smoothing progress: 82% - minimum remaining time: 0m 0s
Smoothing progress: 84% - minimum remaining time: 0m 0s
Smoothing progress: 85% - minimum remaining time: 0m 0s
Smoothing progress: 87% - minimum remaining time: 0m 0s
Smoothing progress: 89% - minimum remaining time: 0m 0s
Smoothing progress: 91% - minimum remaining time: 0m 0s
Smoothing progress: 92% - minimum remaining time: 0m 0s
Smoothing progress: 94% - minimum remaining time: 0m 0s
Smoothing progress: 96% - minimum remaining time: 0m 0s
Smoothing progress: 98% - minimum remaining time: 0m 0s
Smoothing duration: 0m 0s                                                                                           

# Filtrage des carreaux lissés dans Paris
sfcarLisse <- sfcarLisse[unlist(st_intersects(centreBdx,sfcarLisse)),]

# Carte lissée
genercarte(sfcarLisse=sfcarLisse,
                       nomvar="np_pmr",
                       nbreaks=5,
                       zone=centreBdx,
                       titre="Lissage des places de stationnement PMR")

Partie 2.4 : Lissage de ratios

Exercice 11

Lisser le nombre moyen de places de stationnement par parking.

Indices

Ne jamais lisser directement le ratio ! On lisse le numérateur et le dénominateur, puis on fait le ratio sur les carreaux générés par `kernelSmoothing`.

Solution

parkingsLissage <- parkingBuff[,c("nbObsLisse","np_global","x","y")]

sfcarLisse <- btb::kernelSmoothing(dfObservations = parkingsLissage, 
                                    sEPSG = "2154",
                                    iCellSize = tcar, 
                                    iBandwidth = rayon)

Smoothing progress: 1% - minimum remaining time: 0m 0s
Smoothing progress: 3% - minimum remaining time: 0m 0s
Smoothing progress: 5% - minimum remaining time: 0m 0s
Smoothing progress: 7% - minimum remaining time: 0m 0s
Smoothing progress: 8% - minimum remaining time: 0m 0s
Smoothing progress: 10% - minimum remaining time: 0m 0s
Smoothing progress: 12% - minimum remaining time: 0m 0s
Smoothing progress: 14% - minimum remaining time: 0m 0s
Smoothing progress: 15% - minimum remaining time: 0m 0s
Smoothing progress: 17% - minimum remaining time: 0m 0s
Smoothing progress: 19% - minimum remaining time: 0m 0s
Smoothing progress: 21% - minimum remaining time: 0m 0s
Smoothing progress: 22% - minimum remaining time: 0m 0s
Smoothing progress: 24% - minimum remaining time: 0m 0s
Smoothing progress: 26% - minimum remaining time: 0m 0s
Smoothing progress: 28% - minimum remaining time: 0m 0s
Smoothing progress: 29% - minimum remaining time: 0m 0s
Smoothing progress: 31% - minimum remaining time: 0m 0s
Smoothing progress: 33% - minimum remaining time: 0m 0s
Smoothing progress: 35% - minimum remaining time: 0m 0s
Smoothing progress: 36% - minimum remaining time: 0m 0s
Smoothing progress: 38% - minimum remaining time: 0m 0s
Smoothing progress: 40% - minimum remaining time: 0m 0s
Smoothing progress: 42% - minimum remaining time: 0m 0s
Smoothing progress: 43% - minimum remaining time: 0m 0s
Smoothing progress: 45% - minimum remaining time: 0m 0s
Smoothing progress: 47% - minimum remaining time: 0m 0s
Smoothing progress: 49% - minimum remaining time: 0m 0s
Smoothing progress: 50% - minimum remaining time: 0m 0s
Smoothing progress: 52% - minimum remaining time: 0m 0s
Smoothing progress: 54% - minimum remaining time: 0m 0s
Smoothing progress: 56% - minimum remaining time: 0m 0s
Smoothing progress: 57% - minimum remaining time: 0m 0s
Smoothing progress: 59% - minimum remaining time: 0m 0s
Smoothing progress: 61% - minimum remaining time: 0m 0s
Smoothing progress: 63% - minimum remaining time: 0m 0s
Smoothing progress: 64% - minimum remaining time: 0m 0s
Smoothing progress: 66% - minimum remaining time: 0m 0s
Smoothing progress: 68% - minimum remaining time: 0m 0s
Smoothing progress: 70% - minimum remaining time: 0m 0s
Smoothing progress: 71% - minimum remaining time: 0m 0s
Smoothing progress: 73% - minimum remaining time: 0m 0s
Smoothing progress: 75% - minimum remaining time: 0m 0s
Smoothing progress: 77% - minimum remaining time: 0m 0s
Smoothing progress: 78% - minimum remaining time: 0m 0s
Smoothing progress: 80% - minimum remaining time: 0m 0s
Smoothing progress: 82% - minimum remaining time: 0m 0s
Smoothing progress: 84% - minimum remaining time: 0m 0s
Smoothing progress: 85% - minimum remaining time: 0m 0s
Smoothing progress: 87% - minimum remaining time: 0m 0s
Smoothing progress: 89% - minimum remaining time: 0m 0s
Smoothing progress: 91% - minimum remaining time: 0m 0s
Smoothing progress: 92% - minimum remaining time: 0m 0s
Smoothing progress: 94% - minimum remaining time: 0m 0s
Smoothing progress: 96% - minimum remaining time: 0m 0s
Smoothing progress: 98% - minimum remaining time: 0m 0s
Smoothing duration: 0m 0s                                                                                           

# Création du ratio lissé à partir des numérateur et dénominateur lissés
sfcarLisse <- sfcarLisse %>% mutate(place_par_parking=np_global/nbObsLisse)

sfcarLisse <- sfcarLisse[unlist(st_intersects(centreBdx,sfcarLisse)),]
genercarte(sfcarLisse=sfcarLisse,
                       nomvar="place_par_parking",
                       nbreaks=5,
                       zone=centreBdx,
                       titre="Lissage du nombre de places par parking")

Exercice 12

Lisser le taux de place de stationnement pour personnes à mobilité réduite.

Solution

parkingsLissage <- parkingBuff[,c("np_global","np_pmr","x","y")]

sfcarLisse <- btb::kernelSmoothing(dfObservations = parkingsLissage, 
                                    sEPSG = "2154",
                                    iCellSize = tcar, 
                                    iBandwidth = rayon)

Smoothing progress: 1% - minimum remaining time: 0m 0s
Smoothing progress: 3% - minimum remaining time: 0m 0s
Smoothing progress: 5% - minimum remaining time: 0m 0s
Smoothing progress: 7% - minimum remaining time: 0m 0s
Smoothing progress: 8% - minimum remaining time: 0m 0s
Smoothing progress: 10% - minimum remaining time: 0m 0s
Smoothing progress: 12% - minimum remaining time: 0m 0s
Smoothing progress: 14% - minimum remaining time: 0m 0s
Smoothing progress: 15% - minimum remaining time: 0m 0s
Smoothing progress: 17% - minimum remaining time: 0m 0s
Smoothing progress: 19% - minimum remaining time: 0m 0s
Smoothing progress: 21% - minimum remaining time: 0m 0s
Smoothing progress: 22% - minimum remaining time: 0m 0s
Smoothing progress: 24% - minimum remaining time: 0m 0s
Smoothing progress: 26% - minimum remaining time: 0m 0s
Smoothing progress: 28% - minimum remaining time: 0m 0s
Smoothing progress: 29% - minimum remaining time: 0m 0s
Smoothing progress: 31% - minimum remaining time: 0m 0s
Smoothing progress: 33% - minimum remaining time: 0m 0s
Smoothing progress: 35% - minimum remaining time: 0m 0s
Smoothing progress: 36% - minimum remaining time: 0m 0s
Smoothing progress: 38% - minimum remaining time: 0m 0s
Smoothing progress: 40% - minimum remaining time: 0m 0s
Smoothing progress: 42% - minimum remaining time: 0m 0s
Smoothing progress: 43% - minimum remaining time: 0m 0s
Smoothing progress: 45% - minimum remaining time: 0m 0s
Smoothing progress: 47% - minimum remaining time: 0m 0s
Smoothing progress: 49% - minimum remaining time: 0m 0s
Smoothing progress: 50% - minimum remaining time: 0m 0s
Smoothing progress: 52% - minimum remaining time: 0m 0s
Smoothing progress: 54% - minimum remaining time: 0m 0s
Smoothing progress: 56% - minimum remaining time: 0m 0s
Smoothing progress: 57% - minimum remaining time: 0m 0s
Smoothing progress: 59% - minimum remaining time: 0m 0s
Smoothing progress: 61% - minimum remaining time: 0m 0s
Smoothing progress: 63% - minimum remaining time: 0m 0s
Smoothing progress: 64% - minimum remaining time: 0m 0s
Smoothing progress: 66% - minimum remaining time: 0m 0s
Smoothing progress: 68% - minimum remaining time: 0m 0s
Smoothing progress: 70% - minimum remaining time: 0m 0s
Smoothing progress: 71% - minimum remaining time: 0m 0s
Smoothing progress: 73% - minimum remaining time: 0m 0s
Smoothing progress: 75% - minimum remaining time: 0m 0s
Smoothing progress: 77% - minimum remaining time: 0m 0s
Smoothing progress: 78% - minimum remaining time: 0m 0s
Smoothing progress: 80% - minimum remaining time: 0m 0s
Smoothing progress: 82% - minimum remaining time: 0m 0s
Smoothing progress: 84% - minimum remaining time: 0m 0s
Smoothing progress: 85% - minimum remaining time: 0m 0s
Smoothing progress: 87% - minimum remaining time: 0m 0s
Smoothing progress: 89% - minimum remaining time: 0m 0s
Smoothing progress: 91% - minimum remaining time: 0m 0s
Smoothing progress: 92% - minimum remaining time: 0m 0s
Smoothing progress: 94% - minimum remaining time: 0m 0s
Smoothing progress: 96% - minimum remaining time: 0m 0s
Smoothing progress: 98% - minimum remaining time: 0m 0s
Smoothing duration: 0m 0s                                                                                           

# Création du ratio lissé à partir des numérateur et dénominateur lissés
sfcarLisse$part_pmf <- sfcarLisse$np_pmr/sfcarLisse$np_global

sfcarLisse <- sfcarLisse[unlist(st_intersects(centreBdx,sfcarLisse)),]
genercarte(sfcarLisse=sfcarLisse,
                       nomvar="part_pmf",
                       nbreaks=5,
                       zone=centreBdx,
                       titre="Lissage de la part de places PMR")

Partie 2.5 (bonus) : où trouver des places de parking pas chères ?

Exercice 13

Lisser le prix moyen d'une heure de stationnement par parking (sans pondérer par le nombre de places)

Solution

parkingsLissage <- parkingBuff[,c("nbObsLisse","th_heur","x","y")]
sfcarLisse <- btb::kernelSmoothing(dfObservations = parkingsLissage, 
                                    sEPSG = "2154",
                                    iCellSize = tcar, 
                                    iBandwidth = rayon)

Smoothing progress: 1% - minimum remaining time: 0m 0s
Smoothing progress: 3% - minimum remaining time: 0m 0s
Smoothing progress: 5% - minimum remaining time: 0m 0s
Smoothing progress: 7% - minimum remaining time: 0m 0s
Smoothing progress: 8% - minimum remaining time: 0m 0s
Smoothing progress: 10% - minimum remaining time: 0m 0s
Smoothing progress: 12% - minimum remaining time: 0m 0s
Smoothing progress: 14% - minimum remaining time: 0m 0s
Smoothing progress: 15% - minimum remaining time: 0m 0s
Smoothing progress: 17% - minimum remaining time: 0m 0s
Smoothing progress: 19% - minimum remaining time: 0m 0s
Smoothing progress: 21% - minimum remaining time: 0m 0s
Smoothing progress: 22% - minimum remaining time: 0m 0s
Smoothing progress: 24% - minimum remaining time: 0m 0s
Smoothing progress: 26% - minimum remaining time: 0m 0s
Smoothing progress: 28% - minimum remaining time: 0m 0s
Smoothing progress: 29% - minimum remaining time: 0m 0s
Smoothing progress: 31% - minimum remaining time: 0m 0s
Smoothing progress: 33% - minimum remaining time: 0m 0s
Smoothing progress: 35% - minimum remaining time: 0m 0s
Smoothing progress: 36% - minimum remaining time: 0m 0s
Smoothing progress: 38% - minimum remaining time: 0m 0s
Smoothing progress: 40% - minimum remaining time: 0m 0s
Smoothing progress: 42% - minimum remaining time: 0m 0s
Smoothing progress: 43% - minimum remaining time: 0m 0s
Smoothing progress: 45% - minimum remaining time: 0m 0s
Smoothing progress: 47% - minimum remaining time: 0m 0s
Smoothing progress: 49% - minimum remaining time: 0m 0s
Smoothing progress: 50% - minimum remaining time: 0m 0s
Smoothing progress: 52% - minimum remaining time: 0m 0s
Smoothing progress: 54% - minimum remaining time: 0m 0s
Smoothing progress: 56% - minimum remaining time: 0m 0s
Smoothing progress: 57% - minimum remaining time: 0m 0s
Smoothing progress: 59% - minimum remaining time: 0m 0s
Smoothing progress: 61% - minimum remaining time: 0m 0s
Smoothing progress: 63% - minimum remaining time: 0m 0s
Smoothing progress: 64% - minimum remaining time: 0m 0s
Smoothing progress: 66% - minimum remaining time: 0m 0s
Smoothing progress: 68% - minimum remaining time: 0m 0s
Smoothing progress: 70% - minimum remaining time: 0m 0s
Smoothing progress: 71% - minimum remaining time: 0m 0s
Smoothing progress: 73% - minimum remaining time: 0m 0s
Smoothing progress: 75% - minimum remaining time: 0m 0s
Smoothing progress: 77% - minimum remaining time: 0m 0s
Smoothing progress: 78% - minimum remaining time: 0m 0s
Smoothing progress: 80% - minimum remaining time: 0m 0s
Smoothing progress: 82% - minimum remaining time: 0m 0s
Smoothing progress: 84% - minimum remaining time: 0m 0s
Smoothing progress: 85% - minimum remaining time: 0m 0s
Smoothing progress: 87% - minimum remaining time: 0m 0s
Smoothing progress: 89% - minimum remaining time: 0m 0s
Smoothing progress: 91% - minimum remaining time: 0m 0s
Smoothing progress: 92% - minimum remaining time: 0m 0s
Smoothing progress: 94% - minimum remaining time: 0m 0s
Smoothing progress: 96% - minimum remaining time: 0m 0s
Smoothing progress: 98% - minimum remaining time: 0m 0s
Smoothing duration: 0m 0s                                                                                           

sfcarLisse$prix_moyen <- sfcarLisse$th_heur/sfcarLisse$nbObsLisse

sfcarLisse <- sfcarLisse[unlist(st_intersects(centreBdx,sfcarLisse)),]
genercarte(sfcarLisse=sfcarLisse,
                       nomvar="prix_moyen",
                       nbreaks=5,
                       zone=centreBdx,
                       titre="Lissage du prix par parking (sans pondération)")

Exercice 14

Lisser le prix moyen d'une heure de stationnement (prendre en compte le nombre de places de stationnement par parking).

Indices

Pour chaque parking de la base, il faut lisser :
  - la multiplication du prix et du nombre de place
  - le nombre de place
et faire le ratio pour obtenir le "prix moyen d'une place" lissé.

Solution

# Création de la variable "multiplication du prix et du nmbre de places" pour chaque parking
parkingBuff <- parkingBuff %>% mutate(prix_x_place=np_global*th_heur)

parkingsLissage <- parkingBuff[,c("np_global","prix_x_place","x","y")]

sfcarLisse <- btb::kernelSmoothing(dfObservations = parkingsLissage, 
                                    sEPSG = "2154",
                                    iCellSize = tcar, 
                                    iBandwidth = rayon)

Smoothing progress: 1% - minimum remaining time: 0m 0s
Smoothing progress: 3% - minimum remaining time: 0m 0s
Smoothing progress: 5% - minimum remaining time: 0m 0s
Smoothing progress: 7% - minimum remaining time: 0m 0s
Smoothing progress: 8% - minimum remaining time: 0m 0s
Smoothing progress: 10% - minimum remaining time: 0m 0s
Smoothing progress: 12% - minimum remaining time: 0m 0s
Smoothing progress: 14% - minimum remaining time: 0m 0s
Smoothing progress: 15% - minimum remaining time: 0m 0s
Smoothing progress: 17% - minimum remaining time: 0m 0s
Smoothing progress: 19% - minimum remaining time: 0m 0s
Smoothing progress: 21% - minimum remaining time: 0m 0s
Smoothing progress: 22% - minimum remaining time: 0m 0s
Smoothing progress: 24% - minimum remaining time: 0m 0s
Smoothing progress: 26% - minimum remaining time: 0m 0s
Smoothing progress: 28% - minimum remaining time: 0m 0s
Smoothing progress: 29% - minimum remaining time: 0m 0s
Smoothing progress: 31% - minimum remaining time: 0m 0s
Smoothing progress: 33% - minimum remaining time: 0m 0s
Smoothing progress: 35% - minimum remaining time: 0m 0s
Smoothing progress: 36% - minimum remaining time: 0m 0s
Smoothing progress: 38% - minimum remaining time: 0m 0s
Smoothing progress: 40% - minimum remaining time: 0m 0s
Smoothing progress: 42% - minimum remaining time: 0m 0s
Smoothing progress: 43% - minimum remaining time: 0m 0s
Smoothing progress: 45% - minimum remaining time: 0m 0s
Smoothing progress: 47% - minimum remaining time: 0m 0s
Smoothing progress: 49% - minimum remaining time: 0m 0s
Smoothing progress: 50% - minimum remaining time: 0m 0s
Smoothing progress: 52% - minimum remaining time: 0m 0s
Smoothing progress: 54% - minimum remaining time: 0m 0s
Smoothing progress: 56% - minimum remaining time: 0m 0s
Smoothing progress: 57% - minimum remaining time: 0m 0s
Smoothing progress: 59% - minimum remaining time: 0m 0s
Smoothing progress: 61% - minimum remaining time: 0m 0s
Smoothing progress: 63% - minimum remaining time: 0m 0s
Smoothing progress: 64% - minimum remaining time: 0m 0s
Smoothing progress: 66% - minimum remaining time: 0m 0s
Smoothing progress: 68% - minimum remaining time: 0m 0s
Smoothing progress: 70% - minimum remaining time: 0m 0s
Smoothing progress: 71% - minimum remaining time: 0m 0s
Smoothing progress: 73% - minimum remaining time: 0m 0s
Smoothing progress: 75% - minimum remaining time: 0m 0s
Smoothing progress: 77% - minimum remaining time: 0m 0s
Smoothing progress: 78% - minimum remaining time: 0m 0s
Smoothing progress: 80% - minimum remaining time: 0m 0s
Smoothing progress: 82% - minimum remaining time: 0m 0s
Smoothing progress: 84% - minimum remaining time: 0m 0s
Smoothing progress: 85% - minimum remaining time: 0m 0s
Smoothing progress: 87% - minimum remaining time: 0m 0s
Smoothing progress: 89% - minimum remaining time: 0m 0s
Smoothing progress: 91% - minimum remaining time: 0m 0s
Smoothing progress: 92% - minimum remaining time: 0m 0s
Smoothing progress: 94% - minimum remaining time: 0m 0s
Smoothing progress: 96% - minimum remaining time: 0m 0s
Smoothing progress: 98% - minimum remaining time: 0m 0s
Smoothing duration: 0m 0s                                                                                           

# Et on rapport par le nombre de places lissé.
sfcarLisse <- sfcarLisse %>% mutate(prix_moyen_place=prix_x_place/np_global)


sfcarLisse <- sfcarLisse[unlist(st_intersects(centreBdx,sfcarLisse)),]

# Carte lissée
genercarte(sfcarLisse=sfcarLisse,
                       nomvar="prix_moyen_place",
                       nbreaks=5,
                       zone=centreBdx,
                       titre="Lissage du prix moyen par place de stationnement")

Phase 3 : Calcul d’indicateur sur une zone à façon

Exercice 14

Combien d'habitants vivent dans le centre de Bordeaux tel que nous l'avons défini ?
Pour répondre à cette question : 
  - Charger la base des données Filosofi 2015 carroyées (grille de 200m) en utilisant le code ci-dessous. Le code permet de ne charger que les carreaux de la Gironde.
  - Faire une intersection géographique entre les carreaux de la Gironde et le contour géographique du centre de Bordeaux
  - Calculer le nombre d'habitants grâce à la variable `Ind`

url_bucket <- "https://minio.lab.sspcloud.fr/"
bucket <- "kantunez"

object = "diffusion/projet_formation/r_lissage_spatial/Filosofi2015_carreaux_200m_metropole.gpkg"
st_read_maison <- function(chemin_tab){
  requete <- "SELECT IdINSPIRE,Depcom,Ind,Men, Log_soc, geom
            FROM Filosofi2015_carreaux_200m_metropole
            WHERE SUBSTR(Depcom, 1, 2) IN ('33') "
  sf::st_read(chemin_tab, query = requete)
}

car33 <-  st_read_maison(paste0(url_bucket,bucket,"/",object))

Ou avec aws.s3 :

car33 <- 
  aws.s3::s3read_using(
    FUN = st_read_maison,
    object = object,
    bucket = bucket
    ,
    opts = list("region" = "")
  )

Solution

# Visualisation de la base ==> projection 2154 (en Lambert93) : c'est bon.
head(car33)

Simple feature collection with 6 features and 5 fields
Geometry type: MULTIPOLYGON
Dimension:     XY
Bounding box:  xmin: 380298.5 ymin: 6371417 xmax: 462033.2 ymax: 6482152
Projected CRS: RGF93 / Lambert-93
                       IdINSPIRE Depcom Ind Men Log_soc                           geom
1 CRS3035RES200mN2536800E3454800  33540   8 4.1       0 MULTIPOLYGON (((380316.5 64...
2 CRS3035RES200mN2441800E3514800  33444   6 2.5       0 MULTIPOLYGON (((448527.4 63...
3 CRS3035RES200mN2419200E3522000  33195   2 0.9       0 MULTIPOLYGON (((457694.4 63...
4 CRS3035RES200mN2435400E3527600  33066  10 4.1       0 MULTIPOLYGON (((461834.2 63...
5 CRS3035RES200mN2434000E3524000  33254   8 3.3       0 MULTIPOLYGON (((458375.3 63...
6 CRS3035RES200mN2422600E3510600  33391   2 1.0       0 MULTIPOLYGON (((446047.2 63...

# Sélection des carreaux intersectant le centre de Bordeaux
carreaux_centreBdx <- car33[unlist(st_intersects(centreBdx,car33)),]

# Cartographie :
mapview(centreBdx %>% st_cast("MULTILINESTRING"),
        color="black",
        lwd=4,
        basemaps.color.shuffle=F)+
  mapview(carreaux_centreBdx,col.region="yellow")

# Combien d'habitants dans le centre de Bordeaux ?
cat("Il y a approximativement ",sum(carreaux_centreBdx$Ind), " habitants dans le centre de Bordeaux")

Il y a approximativement  133506.5  habitants dans le centre de Bordeaux

---

---

Reproductibilité

sessionInfo()

R version 4.1.2 (2021-11-01)
Platform: x86_64-apple-darwin17.0 (64-bit)
Running under: macOS Big Sur 10.16

Matrix products: default
BLAS:   /Library/Frameworks/R.framework/Versions/4.1/Resources/lib/libRblas.0.dylib
LAPACK: /Library/Frameworks/R.framework/Versions/4.1/Resources/lib/libRlapack.dylib

locale:
[1] en_US.UTF-8/en_US.UTF-8/en_US.UTF-8/C/en_US.UTF-8/en_US.UTF-8

attached base packages:
[1] stats     graphics  grDevices datasets  utils     methods   base     

other attached packages:
[1] aws.s3_0.3.21     mapview_2.10.0    mapsf_0.4.0       btb_0.1.30.3     
[5] sf_1.0-6          dplyr_1.0.8       unilur_0.4.0.9100 knitr_1.37       

loaded via a namespace (and not attached):
 [1] Rcpp_1.0.8              svglite_2.1.0           lattice_0.20-45        
 [4] leaflet.providers_1.9.0 png_0.1-7               class_7.3-19           
 [7] assertthat_0.2.1        digest_0.6.29           utf8_1.2.2             
[10] aws.signature_0.6.0     R6_2.5.1                leafpop_0.1.0          
[13] stats4_4.1.2            evaluate_0.15           e1071_1.7-9            
[16] highr_0.9               httr_1.4.2              pillar_1.7.0           
[19] rlang_1.0.1             uuid_1.0-3              curl_4.3.2             
[22] raster_3.5-15           jquerylib_0.1.4         rmarkdown_2.11         
[25] webshot_0.5.2           stringr_1.4.0           htmlwidgets_1.5.4      
[28] munsell_0.5.0           proxy_0.4-26            compiler_4.1.2         
[31] xfun_0.29               systemfonts_1.0.4       pkgconfig_2.0.3        
[34] base64enc_0.1-3         htmltools_0.5.2         tidyselect_1.1.2       
[37] tibble_3.1.6            codetools_0.2-18        fansi_1.0.2            
[40] crayon_1.5.0            grid_4.1.2              jsonlite_1.8.0         
[43] satellite_1.0.4         lifecycle_1.0.1         DBI_1.1.2              
[46] magrittr_2.0.2          units_0.8-0             scales_1.1.1           
[49] RcppParallel_5.1.5      KernSmooth_2.23-20      stringi_1.7.6          
[52] farver_2.1.0            renv_0.15.2             leaflet_2.1.0          
[55] sp_1.4-6                xml2_1.3.3              brew_1.0-7             
[58] ellipsis_0.3.2          generics_0.1.2          vctrs_0.3.8            
[61] RColorBrewer_1.1-2      tools_4.1.2             leafem_0.1.6           
[64] glue_1.6.2              purrr_0.3.4             crosstalk_1.2.0        
[67] fastmap_1.1.0           yaml_2.3.5              colorspace_2.0-3       
[70] terra_1.5-21            classInt_0.4-3